home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / SCRIPT.PAK / MATE.SPP < prev    next >
Text File  |  1997-05-06  |  5KB  |  184 lines
  1. //----------------------------------------------------------------------------
  2. // cScript
  3. // (C) Copyright 1995, 1997 by Borland International, All Rights Reserved
  4. //
  5. // MATE.SPP
  6. //    Provides complimentary symbol matching functionality.
  7. //
  8. // $Revision:   1.14  $
  9. //
  10. //----------------------------------------------------------------------------
  11.  
  12. import editor;
  13. import IDE;
  14.  
  15. // mark this module as being a library module
  16. library;
  17.  
  18. //
  19. // A placeholding method used to trigger the load of this module.
  20. //
  21. LoadMateFunctionality(){
  22.    // do nothing
  23. }
  24.  
  25.  
  26. class MateManagement {
  27.  
  28.    declare nDirection = SEARCH_FORWARD;
  29.    declare sMatching  = NULL;
  30.    declare nMatchIndex = 0;
  31.    declare matchData = new array[];
  32.  
  33.    declare ifMatch =      {"if",   "endif"};
  34.    declare parenMatch =   {"(",    ")"};
  35.    declare bracketMatch = {"[",    "]"};
  36.    declare curlyMatch =   {"{",    "}"};
  37.    declare dblQMatch =    {"\"",   "\""};
  38.    declare snglQMatch =   {"\'",   "\'"};
  39.    declare angleMatch =   {"<",    ">"};
  40.  
  41.    declare mateSet = "[\[\](){}\\<>]";
  42.  
  43.    matchData[0] = ifMatch;
  44.    matchData[1] = parenMatch;
  45.    matchData[2] = bracketMatch;
  46.    matchData[3] = curlyMatch;
  47.    matchData[4] = dblQMatch;
  48.    matchData[5] = snglQMatch;
  49.    matchData[6] = angleMatch;
  50.  
  51.    DetermineCorresponding(declare sRequest) {
  52.       for(nMatchIndex = 0;matchData[nMatchIndex] != NULL;nMatchIndex++){
  53.          if (sRequest == matchData[nMatchIndex][0]){
  54.             nDirection = SEARCH_FORWARD;
  55.             sMatching = matchData[nMatchIndex][1];
  56.             break;
  57.          }
  58.  
  59.          if (sRequest == matchData[nMatchIndex][1]){
  60.             nDirection = SEARCH_BACKWARD;
  61.             sMatching  = matchData[nMatchIndex][0];
  62.             break;
  63.          }
  64.       }
  65.  
  66.       if (matchData[nMatchIndex] == NULL)
  67.          return FALSE;
  68.  
  69.       return TRUE;
  70.    }
  71.  
  72.    LocateCorresponding(declare nDirectionOverride) {
  73.       // hopefully our caller will direct us in what to do on an
  74.       // ambiguos match, otherwise we will guess and scan forward.
  75.  
  76.       declare ep = editor.TopView.Position;
  77.  
  78.       declare nEndCorrection = 0;
  79.       declare nStartCorrection = 0;
  80.  
  81.       if (matchData[nMatchIndex][0] == matchData[nMatchIndex][1]) {
  82.          nDirection = (nDirectionOverride == SEARCH_BACKWARD) ?
  83.             SEARCH_BACKWARD : SEARCH_FORWARD;
  84.       }
  85.  
  86.       if (nDirection == SEARCH_FORWARD) {
  87.          nStartCorrection = 1;
  88.          nEndCorrection = -1;
  89.       } else {
  90.          nStartCorrection = 0;
  91.          nEndCorrection = 0;
  92.       }
  93.  
  94.       declare nResult = 1;
  95.       declare nNestingLevel = 1;
  96.       declare acNested = NULL;
  97.       if (matchData[nMatchIndex][0] == "[")
  98.          acNested = "[\\" + matchData[nMatchIndex][0] +"\\" + matchData[nMatchIndex][1] + "]";
  99.       else
  100.          acNested = "[" + matchData[nMatchIndex][0] + matchData[nMatchIndex][1] + "]";
  101.  
  102.       while (nResult && nNestingLevel) {
  103.          ep.MoveRelative(0, nStartCorrection);
  104.  
  105.          nResult = ep.Search(acNested, TRUE, TRUE, nDirection);
  106.  
  107.          if (nResult) {
  108.             ep.MoveRelative(0, nEndCorrection);
  109.             if (ep.Read(1) == sMatching)  
  110.                nNestingLevel--;
  111.             else
  112.                nNestingLevel++;
  113.             }
  114.       }
  115.  
  116.       if (nResult == 0) {
  117.          return FALSE;
  118.       }
  119.  
  120.       return TRUE;
  121.    }
  122.  
  123.    ValidCharacter(declare character) {
  124.       // see if there is anything to match
  125.       if (character == ' ' ||
  126.          character == VIRTUAL_TAB ||
  127.          character == VIRTUAL_PAST_EOF ||
  128.          character == VIRTUAL_PAST_EOL)  {
  129.          return FALSE;
  130.       }
  131.  
  132.       // did we pull a peice of an identifier or a symbol?
  133.       if( ( ('a' <= character) && (character <= 'z')) ||
  134.           (('A' <= character) && (character <= 'Z')) ||
  135.           (('0' <= character) && (character <= '9')) ||
  136.           (character == '_')){
  137.             return FALSE;
  138.       }
  139.  
  140.       return TRUE;
  141.    }
  142. };
  143.  
  144. declare MateManagement MateManager;
  145.  
  146. //
  147. // This method is responsible for navigating to the delimeter that matches
  148. // the "current" delimeter
  149. //
  150. on editor:>Mate(declare dirIfAmbiguous){
  151.    declare ep = .TopView.Position;
  152.    declare nOriginalRow = ep.Row;
  153.    declare nOriginalColumn = ep.Column;
  154.    declare matchingStr = .TopView.Position.Read(1);
  155.  
  156.    if (!MateManager.DetermineCorresponding(matchingStr)) {
  157.       IDE.MessageBeep();
  158.       IDE.StatusBar = "Matching delimeter for '" + matchingStr + "'" + " is unknown.";
  159.       return FALSE;
  160.    }
  161.  
  162.    IDE.StatusBar = "Matching '" + matchingStr + "'...";
  163.  
  164.    if (!MateManager.LocateCorresponding(dirIfAmbiguous)) {
  165.       IDE.MessageBeep();
  166.       IDE.StatusBar = "Failed to find matching '" + matchingStr + "'";
  167.       ep.Move(nOriginalRow,nOriginalColumn);
  168.       return FALSE;
  169.    }
  170.  
  171.    IDE.StatusBar = "Matched '" + matchingStr + "' with '" + MateManager.sMatching + "'";
  172.    return TRUE;
  173. }
  174.  
  175. on editor:>MateQuiet(declare matchingStr, declare dirIfAmbiguous){
  176.    if (!MateManager.DetermineCorresponding(matchingStr))
  177.        return FALSE;
  178.      
  179.    if (!MateManager.LocateCorresponding(dirIfAmbiguous))
  180.        return FALSE;
  181.  
  182.    return TRUE;
  183. }     
  184.